home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zchar1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-21  |  15.6 KB  |  556 lines
  1. /* Copyright (C) 1993, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zchar1.c */
  20. /* Type 1 character display operator */
  21. #include "ghost.h"
  22. #include "errors.h"
  23. #include "oper.h"
  24. #include "gsstruct.h"
  25. #include "gxfixed.h"
  26. #include "gxmatrix.h"
  27. #include "gxchar.h"        /* for gs_type1_init in gstype1.h */
  28.                 /* (should only be gschar.h) */
  29. #include "gxdevice.h"        /* for gxfont.h */
  30. #include "gxfont.h"
  31. #include "gxfont1.h"
  32. #include "gxtype1.h"
  33. #include "gzstate.h"        /* for path for gs_type1_init */
  34.                 /* (should only be gsstate.h) */
  35. #include "gspaint.h"        /* for gs_fill, gs_stroke */
  36. #include "gspath.h"
  37. #include "estack.h"
  38. #include "ialloc.h"
  39. #include "ichar.h"
  40. #include "icharout.h"
  41. #include "idict.h"
  42. #include "ifont.h"
  43. #include "igstate.h"
  44. #include "store.h"
  45.  
  46. /* Test whether a font is Type 1 compatible. */
  47. #define font_is_type1_compatible(pfont)\
  48.   ((pfont)->FontType == ft_encrypted || (pfont)->FontType == ft_disk_based)
  49.  
  50. /* Forward references */
  51. private int type1addpath_continue(P1(os_ptr));
  52. private int type1_call_OtherSubr(P3(gs_type1_state *, int (*)(P1(os_ptr)), const ref *));
  53. private int type1_continue_dispatch(P3(gs_type1_state *, const ref *, ref *));
  54. private int op_type1_cleanup(P1(os_ptr));
  55. private void op_type1_free(P1(os_ptr));
  56.  
  57. /* ---------------- .type1execchar ---------------- */
  58.  
  59. /*
  60.  * This is the workhorse for %Type1BuildChar, %Type1BuildGlyph,
  61.  * CCRun, and CID fonts.  Eventually this will appear in the C API;
  62.  * even now, its normal control path doesn't use any continuations.
  63.  */
  64.  
  65. /* Forward references */
  66. private void
  67.   type1_cis_get_metrics(P2(const gs_type1_state *pcis, float psbw[4]));
  68. /* <font> <code|name> <name> <charstring> .type1execchar - */
  69. private int type1getsbw_continue(P1(os_ptr));
  70. private int bbox_fill(P1(os_ptr));
  71. private int bbox_stroke(P1(os_ptr));
  72. private int nobbox_continue(P1(os_ptr));
  73. private int nobbox_fill(P1(os_ptr));
  74. private int nobbox_stroke(P1(os_ptr));
  75. private int
  76. ztype1execchar(register os_ptr op)
  77. {    gs_font *pfont;
  78. #define pbfont ((gs_font_base *)pfont)
  79. #define pfont1 ((gs_font_type1 *)pfont)
  80.     const gs_type1_data *pdata;
  81.     int code = font_param(op - 3, &pfont);
  82.     gs_show_enum *penum = op_show_find();
  83.     gs_type1_state cis;
  84. #define pcis (&cis)
  85.     int present;
  86.     float sbw[4];
  87.     ref other_subr;
  88.  
  89.     if ( code < 0 )
  90.       return code;
  91.     if ( penum == 0 || !font_is_type1_compatible(pfont) )
  92.       return_error(e_undefined);
  93.     pdata = &pfont1->data;
  94.     /*
  95.      * Any reasonable implementation would execute something like
  96.      *    1 setmiterlimit 0 setlinejoin 0 setlinecap
  97.      * here, but apparently the Adobe implementations aren't reasonable.
  98.      *
  99.      * If this is a stroked font, set the stroke width.
  100.      */
  101.     if ( pfont->PaintType )
  102.       gs_setlinewidth(igs, pfont->StrokeWidth);
  103.     check_estack(3);    /* for continuations */
  104.     /*
  105.      * Execute the definition of the character.
  106.      */
  107.     if ( r_is_proc(op) )
  108.       return zchar_exec_char_proc(op);
  109.     /*
  110.      * The definition must be a Type 1 CharString.
  111.      * Note that we do not require read access: this is deliberate.
  112.      */
  113.     check_type(*op, t_string);
  114.     if ( r_size(op) <= max(pdata->lenIV, 0) )
  115.       return_error(e_invalidfont);
  116.     /*
  117.      * In order to make character oversampling work, we must
  118.      * set up the cache before calling .type1addpath.
  119.      * To do this, we must get the bounding box from the FontBBox,
  120.      * and the width from the CharString or the Metrics.
  121.      * If the FontBBox isn't valid, we can't do any of this.
  122.      */
  123.     check_ostack(3);    /* for .type1xxx args */
  124.     present = zchar_get_metrics(pbfont, op - 1, sbw);
  125.     if ( present < 0 )
  126.       return present;
  127.     /* Establish a current point. */
  128.     code = gs_moveto(igs, 0.0, 0.0);
  129.     if ( code < 0 )
  130.       return code;
  131.     code = gs_type1_init(pcis, penum, NULL,
  132.                  gs_show_in_charpath(penum) != cpm_show,
  133.                  pfont1->PaintType, pfont1);
  134.     if ( code < 0 )
  135.       return code;
  136.     if ( pfont1->FontBBox.q.x > pfont1->FontBBox.p.x &&
  137.          pfont1->FontBBox.q.y > pfont1->FontBBox.p.y
  138.        )
  139.       {    /*
  140.          * We have a valid bounding box.  If we don't have Metrics
  141.          * for this character, start interpreting the CharString;
  142.          * do the setcachedevice as soon as we know the
  143.          * (side bearing and) width.
  144.          */
  145.         if ( present == metricsNone )
  146.         {    /* Get the width from the CharString, */
  147.             /* then set the cache device. */
  148.             ref cnref;
  149.  
  150.             /* Since an OtherSubr callout might change osp, */
  151.             /* save the character name now. */
  152.             ref_assign(&cnref, op - 1);
  153.             code = type1_continue_dispatch(pcis, op, &other_subr);
  154.             switch ( code )
  155.               {
  156.               default:        /* code < 0 or done, error */
  157.                 return((code < 0 ? code :
  158.                     gs_note_error(e_invalidfont)));
  159.               case type1_result_callothersubr:    /* unknown OtherSubr */
  160.                 return type1_call_OtherSubr(pcis,
  161.                             type1getsbw_continue,
  162.                             &other_subr);
  163.               case type1_result_sbw:    /* [h]sbw, done */
  164.                 break;
  165.               }
  166.             type1_cis_get_metrics(pcis, sbw);
  167.             return zchar_set_cache(osp, pbfont, &cnref,
  168.                            NULL, sbw + 2,
  169.                            &pfont1->FontBBox,
  170.                            bbox_fill, bbox_stroke);
  171.         }
  172.         else
  173.         {    /* We have the width and bounding box: */
  174.             /* set up the cache device now. */
  175.             return zchar_set_cache(op, pbfont, op - 1,
  176.                            (present ==
  177.                         metricsSideBearingAndWidth ?
  178.                         sbw : NULL),
  179.                            sbw + 2, &pfont1->FontBBox,
  180.                            bbox_fill, bbox_stroke);
  181.         }
  182.       }
  183.     else
  184.       {    /*
  185.          * The FontBBox is not valid.  In this case,
  186.          * we do the .type1addpath first, then the setcachedevice.
  187.          * Oversampling is not possible.
  188.          */
  189.         const ref *opstr = op;
  190.         if ( present == metricsSideBearingAndWidth )
  191.         {    gs_point sbpt;
  192.             sbpt.x = sbw[0], sbpt.y = sbw[1];
  193.             gs_type1_set_lsb(pcis, &sbpt);
  194.         }
  195.         /* Continue interpreting. */
  196. icont:        code = type1_continue_dispatch(pcis, opstr, &other_subr);
  197.         switch ( code )
  198.           {
  199.           case 0:            /* all done */
  200.             break;
  201.           default:            /* code < 0, error */
  202.             return code;
  203.           case type1_result_callothersubr:    /* unknown OtherSubr */
  204.             push_op_estack(nobbox_continue);
  205.             return type1_call_OtherSubr(pcis, type1addpath_continue,
  206.                         &other_subr);
  207.           case type1_result_sbw:    /* [h]sbw, just continue */
  208.             opstr = 0;
  209.             goto icont;
  210.           }
  211.         pop(1);  op -= 1;        /* pop the charstring */
  212.         return nobbox_continue(op);
  213.       }
  214. #undef pcis
  215. #undef pfont1
  216. #undef pbfont
  217. }
  218.  
  219. /* Handle the results of gs_type1_interpret. */
  220. /* pcref points to a t_string ref. */
  221. private int
  222. type1_continue_dispatch(gs_type1_state *pcis, const ref *pcref, ref *pos)
  223. {    int value;
  224.     int code;
  225.     gs_const_string charstring;
  226.     gs_const_string *pchars;
  227.  
  228.     if ( pcref == 0 )
  229.       {    pchars = 0;
  230.       }
  231.     else
  232.       {    charstring.data = pcref->value.const_bytes;
  233.         charstring.size = r_size(pcref);
  234.         pchars = &charstring;
  235.       }
  236.     code = gs_type1_interpret(pcis, pchars, &value);
  237.     switch ( code )
  238.     {
  239.     case type1_result_callothersubr:
  240.     {    /* The Type 1 interpreter handles all known OtherSubrs, */
  241.         /* so this must be an unknown one. */
  242.         font_data *pfdata = pfont_data(gs_currentfont(igs));
  243.         code = array_get(&pfdata->u.type1.OtherSubrs,
  244.                  (long)value, pos);
  245.         return (code < 0 ? code : type1_result_callothersubr);
  246.     }
  247.     }
  248.     return code;
  249. }
  250.  
  251. /* Do a callout to an OtherSubr implemented in PostScript. */
  252. /* The caller must have done a check_estack. */
  253. private int
  254. type1_call_OtherSubr(gs_type1_state *pcis, int (*cont)(P1(os_ptr)),
  255.   const ref *pos)
  256. {    /* Move the Type 1 interpreter state to the heap. */
  257.     gs_type1_state *hpcis = ialloc_struct(gs_type1_state,
  258.                          &st_gs_type1_state,
  259.                          ".type1addpath");
  260.  
  261.     if ( hpcis == 0 )
  262.       return_error(e_VMerror);
  263.     *hpcis = *pcis;
  264.     push_mark_estack(es_show, op_type1_cleanup);
  265.     ++esp;
  266.     make_istruct(esp, 0, hpcis);
  267.     push_op_estack(cont);
  268.     ++esp;
  269.     *esp = *pos;
  270.     return o_push_estack;
  271. }
  272.  
  273. /* Continue from an OtherSubr callout while getting metrics. */
  274. private int
  275. type1getsbw_continue(os_ptr op)
  276. {    ref other_subr;
  277.     gs_type1_state *pcis = r_ptr(esp, gs_type1_state);
  278.     int code;
  279.  
  280.     check_ostack(3);    /* for returning the result */
  281.     code = type1_continue_dispatch(pcis, NULL, &other_subr);
  282.     op = osp;        /* in case z1_push/pop_proc was called */
  283.     switch ( code )
  284.     {
  285.     default:        /* code < 0 or done, error */
  286.         op_type1_free(op);
  287.         return((code < 0 ? code : gs_note_error(e_invalidfont)));
  288.     case type1_result_callothersubr:    /* unknown OtherSubr */
  289.         push_op_estack(type1getsbw_continue);
  290.         ++esp;
  291.         *esp = other_subr;
  292.         return o_push_estack;
  293.     case type1_result_sbw:            /* [h]sbw, done */
  294.       {    float sbw[4];
  295.         const gs_font_base *pbfont =
  296.           (const gs_font_base *)pcis->pfont;
  297.  
  298.         /* Get the metrics before freeing the state. */
  299.         type1_cis_get_metrics(pcis, sbw);
  300.         op_type1_free(op);
  301.         return zchar_set_cache(op, pbfont, op, sbw, sbw + 2,
  302.                        &pbfont->FontBBox,
  303.                        bbox_fill, bbox_stroke);
  304.       }
  305.     }
  306. }
  307.  
  308. /* Clean up after a Type 1 callout. */
  309. private int
  310. op_type1_cleanup(os_ptr op)
  311. {    ifree_object(r_ptr(esp + 2, void), "op_type1_cleanup");
  312.     return 0;
  313. }
  314. private void
  315. op_type1_free(os_ptr op)
  316. {    ifree_object(r_ptr(esp, void), "op_type1_free");
  317.     /*
  318.      * In order to avoid popping from the e-stack and then pushing onto
  319.      * it, which would violate an interpreter invariant, we simply
  320.      * overwrite the two e-stack items being discarded (hpcis and the
  321.      * cleanup operator) with empty procedures.
  322.      */
  323.     make_empty_const_array(esp - 1, a_readonly + a_executable);
  324.     make_empty_const_array(esp, a_readonly + a_executable);
  325. }
  326.  
  327. /* <font> <code|name> <name> <charstring> <sbx> <sby> %bbox_{fill|stroke} - */
  328. /* <font> <code|name> <name> <charstring> %bbox_{fill|stroke} - */
  329. private int bbox_finish(P2(os_ptr, int (*)(P1(os_ptr))));
  330. private int
  331. bbox_fill(os_ptr op)
  332. {    return bbox_finish(op, nobbox_fill);
  333. }
  334. private int
  335. bbox_stroke(os_ptr op)
  336. {    return bbox_finish(op, nobbox_stroke);
  337. }
  338. private int
  339. bbox_finish(os_ptr op, int (*cont)(P1(os_ptr)))
  340. {    gs_font *pfont;
  341. #define pfont1 ((gs_font_type1 *)pfont)
  342.     gs_type1_data *pdata;
  343.     int code;
  344.     gs_show_enum *penum = op_show_find();
  345.     gs_type1_state cis;        /* stack allocate to avoid sandbars */
  346. #define pcis (&cis)
  347.     float sbxy[2];
  348.     gs_point sbpt;
  349.     gs_point *psbpt = 0;
  350.     os_ptr opc = op;
  351.     const ref *opstr;
  352.     ref other_subr;
  353.  
  354.     if ( !r_has_type(opc, t_string) )
  355.       {    check_op(3);
  356.         code = num_params(op, 2, sbxy);
  357.         if ( code < 0 )
  358.           return code;
  359.         sbpt.x = sbxy[0];
  360.         sbpt.y = sbxy[1];
  361.         psbpt = &sbpt;
  362.         opc -= 2;
  363.         check_type(*opc, t_string);
  364.       }
  365.     code = font_param(opc - 3, &pfont);
  366.     if ( code < 0 )
  367.       return code;
  368.     if ( penum == 0 || !font_is_type1_compatible(pfont) )
  369.       return_error(e_undefined);
  370.     pdata = &pfont1->data;
  371.     if ( r_size(opc) <= max(pdata->lenIV, 0) )
  372.       return_error(e_invalidfont);
  373.     check_estack(5);    /* in case we need to do a callout */
  374.     code = gs_type1_init(pcis, penum, psbpt,
  375.                  gs_show_in_charpath(penum) != cpm_show,
  376.                  pfont1->PaintType, pfont1);
  377.     if ( code < 0 )
  378.       return code;
  379.     opstr = opc;
  380. icont:    code = type1_continue_dispatch(pcis, opstr, &other_subr);
  381.     switch ( code )
  382.     {
  383.     case 0:            /* all done */
  384.         /* Call the continuation now. */
  385.         pop((psbpt == 0 ? 1 : 3));
  386.         return (*cont)(osp);
  387.     case type1_result_callothersubr:    /* unknown OtherSubr */
  388.         push_op_estack(cont);        /* call later */
  389.         return type1_call_OtherSubr(pcis, type1addpath_continue,
  390.                         &other_subr);
  391.     case type1_result_sbw:            /* [h]sbw, just continue */
  392.         opstr = 0;
  393.         goto icont;
  394.     default:        /* code < 0, error */
  395.         return code;
  396.     }
  397. #undef pfont1
  398. #undef pcis
  399. }
  400.  
  401. /* Continue from an OtherSubr callout. */
  402. private int
  403. type1addpath_continue(os_ptr op)
  404. {    ref other_subr;
  405.     gs_type1_state *pcis = r_ptr(esp, gs_type1_state);
  406.     int code;
  407. cont:    code = type1_continue_dispatch(pcis, NULL, &other_subr);
  408.     op = osp;        /* in case z1_push/pop_proc was called */
  409.     switch ( code )
  410.     {
  411.     case 0:            /* all done */
  412.     {    /* Assume the OtherSubrs didn't mess with the o-stack.... */
  413.         int npop = (r_has_type(op, t_string) ? 1 : 3);
  414.         pop(npop);  op -= npop;
  415.         op_type1_free(op);
  416.         return 0;
  417.     }
  418.     default:        /* code < 0 or done, error */
  419.         op_type1_free(op);
  420.         return((code < 0 ? code : gs_note_error(e_invalidfont)));
  421.     case type1_result_callothersubr:    /* unknown OtherSubr */
  422.         push_op_estack(type1addpath_continue);
  423.         ++esp;
  424.         *esp = other_subr;
  425.         return o_push_estack;
  426.     case type1_result_sbw:            /* [h]sbw, just continue */
  427.         goto cont;
  428.     }
  429. }
  430.  
  431. /* Finish the no-FontBBox case after constructing the path. */
  432. /* <font> <code|name> <name> %nobbox_continue - */
  433. private int
  434. nobbox_continue(os_ptr op)
  435. {    int code;
  436.     gs_rect bbox;
  437.     gs_font *pfont;
  438. #define pbfont ((gs_font_base *)pfont)
  439.     float sbw[4];
  440.  
  441.     if ( (code = gs_pathbbox(igs, &bbox)) < 0 ||
  442.          (code = font_param(op - 2, &pfont)) < 0 ||
  443.          (code = zchar_get_metrics(pbfont, op, sbw)) < 0
  444.        )
  445.       return code;
  446.     if ( code == metricsNone )
  447.     {    gs_point endpt;
  448.         if ( (code = gs_currentpoint(igs, &endpt)) < 0 )
  449.           return code;
  450.         sbw[2] = endpt.x, sbw[3] = endpt.y;
  451.     }
  452.     return zchar_set_cache(op, pbfont, op, NULL, sbw + 2, &bbox,
  453.                    nobbox_fill, nobbox_stroke);
  454. #undef pbfont
  455. }
  456. /* Finish by popping the operands and filling or stroking. */
  457. private int
  458. nobbox_fill(os_ptr op)
  459. {    pop(3);
  460.     return gs_fill(igs);
  461. }
  462. private int
  463. nobbox_stroke(os_ptr op)
  464. {    pop(3);
  465.     return gs_stroke(igs);
  466. }
  467.  
  468. /* ------ Internal procedures ------ */
  469.  
  470. /* Get the metrics (l.s.b. and width) from the Type 1 interpreter. */
  471. private void
  472. type1_cis_get_metrics(const gs_type1_state *pcis, float psbw[4])
  473. {    psbw[0] = fixed2float(pcis->lsb.x);
  474.     psbw[1] = fixed2float(pcis->lsb.y);
  475.     psbw[2] = fixed2float(pcis->width.x);
  476.     psbw[3] = fixed2float(pcis->width.y);
  477. }
  478.  
  479. /* ------ Initialization procedure ------ */
  480.  
  481. BEGIN_OP_DEFS(zchar1_op_defs) {
  482.     {"4.type1execchar", ztype1execchar},
  483.         /* Internal operators */
  484.     {"0%type1addpath_continue", type1addpath_continue},
  485.     {"3%nobbox_fill", nobbox_fill},
  486.     {"3%nobbox_stroke", nobbox_stroke},
  487.     {"0%type1getsbw_continue", type1getsbw_continue},
  488.     {"4%bbox_fill", bbox_fill},
  489.     {"4%bbox_stroke", bbox_stroke},
  490.     {"3%nobbox_continue", nobbox_continue},
  491. END_OP_DEFS(0) }
  492.  
  493. /* ------ Auxiliary procedures for type 1 fonts ------ */
  494.  
  495. /* These are exported for zfont1.c. */
  496.  
  497. int
  498. z1_subr_proc(gs_font_type1 *pfont, int index, bool global,
  499.   gs_const_string *pstr)
  500. {    const font_data *pfdata = pfont_data(pfont);
  501.     ref subr;
  502.     int code;
  503.  
  504.     code = array_get((global ? &pfdata->u.type1.GlobalSubrs :
  505.               &pfdata->u.type1.Subrs),
  506.              index, &subr);
  507.     if ( code < 0 )
  508.       return code;
  509.     check_type_only(subr, t_string);
  510.     pstr->data = subr.value.const_bytes;
  511.     pstr->size = r_size(&subr);
  512.     return 0;
  513. }
  514.  
  515. int
  516. z1_seac_proc(gs_font_type1 *pfont, int index, gs_const_string *pstr)
  517. {    const font_data *pfdata = pfont_data(pfont);
  518.     ref *pcstr;
  519.     ref enc_entry;
  520.     int code = array_get(&StandardEncoding, (long)index, &enc_entry);
  521.  
  522.     if ( code < 0 )
  523.       return code;
  524.     if ( dict_find(&pfdata->CharStrings, &enc_entry, &pcstr) <= 0 )
  525.       return_error(e_undefined);
  526.     check_type_only(*pcstr, t_string);
  527.     pstr->data = pcstr->value.const_bytes;
  528.     pstr->size = r_size(pcstr);
  529.     return 0;
  530. }
  531.  
  532. int
  533. z1_push_proc(gs_font_type1 *ignore, const fixed *pf, int count)
  534. {    const fixed *p = pf + count - 1;
  535.     int i;
  536.  
  537.     check_ostack(count);
  538.     for ( i = 0; i < count; i++, p-- )
  539.       {    osp++;
  540.         make_real(osp, fixed2float(*p));
  541.       }
  542.     return 0;
  543. }
  544.  
  545. int
  546. z1_pop_proc(gs_font_type1 *ignore, fixed *pf)
  547. {    float val;
  548.     int code = num_params(osp, 1, &val);
  549.  
  550.     if ( code < 0 )
  551.       return code;
  552.     *pf = float2fixed(val);
  553.     osp--;
  554.     return 0;
  555. }
  556.